const app = getApp()
const api = require('../../../utils/api')

Page({
  data: {
    currentStatus: 0, // 0: 全部, 1: 待付款, 2: 待发货, 3: 待收货, 4: 已完成, 5: 已取消
    orders: [],
    loading: false,
    loadingMore: false,
    hasMore: true,
    page: 1,
    pageSize: 10,
    // 客户订单状态映射表
    statusMap: {
      1: '待付款',
      2: '待发货',
      3: '待收货',
      4: '已完成',
      5: '已取消'
    },
    showReviewButtons: false // 是否显示评价按钮
  },

  onLoad(options) {
    console.log('订单列表页面加载, 参数:', options);
    
    // 如果是从个人中心的购买历史跳转过来，显示评价按钮
    if (options && options.showReviewButtons) {
      this.setData({
        showReviewButtons: options.showReviewButtons === 'true'
      });
      console.log('设置显示评价按钮:', this.data.showReviewButtons);
    }
    
    // 如果有状态参数，切换到对应标签
    if (options.status) {
      this.setData({
        currentStatus: parseInt(options.status)
      });
    }
    // 立即加载订单列表
    this.loadOrders();
  },

  onShow() {
    // 每次显示页面时刷新订单列表
    this.setData({
      page: 1,
      orders: [],
      hasMore: true
    });
    // 添加延时，确保后端数据已更新
    setTimeout(() => {
      this.loadOrders();
    }, 300);
  },

  // 切换订单状态
  async switchStatus(e) {
    const status = parseInt(e.currentTarget.dataset.status);
    if (status !== this.data.currentStatus) {
      this.setData({
        currentStatus: status,
        page: 1,
        orders: [],
        hasMore: true
      });
      await this.loadOrders();
    }
  },

  // 加载订单列表
  async loadOrders() {
    if (this.data.loading || !this.data.hasMore) return;

    try {
      this.setData({ loading: true });
      
      const params = {
        page: this.data.page - 1,
        size: this.data.pageSize
      };

      // 如果是"全部"状态，传undefined让后端返回所有订单
      const status = this.data.currentStatus === 0 ? undefined : this.data.currentStatus;
      console.log('加载订单列表, 状态:', status, '参数:', params);
      
      const res = await api.getCustomerOrders(status, params);
      console.log('订单列表响应:', res);
      
      // 详细打印订单原始数据
      if (res.success && res.data && res.data.content) {
        console.log('=== 订单原始数据 ===');
        res.data.content.forEach((order, index) => {
          console.log(`订单[${index}]:`, JSON.stringify({
            orderNo: order.orderNo,
            status: order.status,
            statusText: order.statusText,
            type: typeof order.status
          }));
        });
        
        // 处理订单数据
        const formattedOrders = res.data.content.map(order => {
          // 检查订单是否已评价
          const isReviewed = order.isReviewed === true;
          
          // 获取商品列表
          const products = order.orderItems ? order.orderItems.map(item => ({
            id: item.id,
            name: item.productName,
            price: item.productPrice,
            quantity: item.quantity,
            imageUrl: item.imageUrl || (item.product ? item.product.imageUrl : null) || '/images/default-product.png'
          })) : [];
          
          // 确保每个订单项都有图片URL
          products.forEach(product => {
            if (!product.imageUrl || product.imageUrl === 'undefined' || product.imageUrl === 'null') {
              product.imageUrl = '/images/default-product.png';
            }
          });

          return {
            ...order,
            products: products,
            statusText: this.getStatusText(order.status),
            reviewed: isReviewed // 添加是否已评价的标志
          };
        });

        // 更新订单列表
        this.setData({
          orders: this.data.page === 1 ? formattedOrders : [...this.data.orders, ...formattedOrders],
          hasMore: !res.data.last,
          page: this.data.page + 1
        });
      } else {
        this.setData({ hasMore: false });
        
        if (!res.success) {
          wx.showToast({
            title: res.message || '加载失败',
            icon: 'none'
          });
        }
      }
    } catch (error) {
      console.error('加载订单列表失败:', error);
      wx.showToast({
        title: '加载失败，请重试',
        icon: 'none'
      });
    } finally {
      this.setData({ loading: false });
    }
  },

  // 下拉刷新
  async onPullDownRefresh() {
    this.setData({
      page: 1,
      orders: [],
      hasMore: true
    });
    await this.loadOrders();
    wx.stopPullDownRefresh();
  },

  // 上拉加载更多
  async onReachBottom() {
    if (this.data.hasMore) {
      await this.loadOrders();
    }
  },

  // 格式化价格
  formatPrice(price) {
    return parseFloat(price).toFixed(2)
  },

  // 获取订单状态文本
  getStatusText(status) {
    return this.data.statusMap[status] || '未知状态'
  },

  // 查看订单详情
  onViewDetail(e) {
    const { orderNo } = e.currentTarget.dataset
    wx.navigateTo({
      url: `/pages/order/detail/detail?orderNo=${orderNo}`
    })
  },

  // 取消订单
  async cancelOrder(e) {
    const { orderNo } = e.currentTarget.dataset;
    
    if (!orderNo) {
      wx.showToast({
        title: '订单号不存在',
        icon: 'none'
      });
      return;
    }
    
    wx.showModal({
      title: '提示',
      content: '确定要取消此订单吗？',
      success: async (res) => {
        if (res.confirm) {
          try {
            const res = await api.cancelCustomerOrder(orderNo);
            if (res.success) {
              wx.showToast({
                title: '取消成功',
                icon: 'success'
              });
              // 重新加载订单列表
              this.setData({
                page: 1,
                orders: [],
                hasMore: true
              });
              this.loadOrders();
            } else {
              wx.showToast({
                title: res.message || '取消失败',
                icon: 'none'
              });
            }
          } catch (error) {
            console.error('取消订单失败:', error);
            wx.showToast({
              title: '取消失败',
              icon: 'none'
            });
          }
        }
      }
    });
  },

  // 支付订单
  async payOrder(e) {
    const { orderNo } = e.currentTarget.dataset;
    
    if (!orderNo) {
      wx.showToast({
        title: '订单号不存在',
        icon: 'none'
      });
      return;
    }
    
    try {
      const res = await api.payCustomerOrder(orderNo);
      if (res.success) {
        wx.showToast({
          title: '支付成功',
          icon: 'success'
        });
        // 重新加载订单列表
        this.setData({
          page: 1,
          orders: [],
          hasMore: true
        });
        this.loadOrders();
      } else {
        wx.showToast({
          title: res.message || '支付失败',
          icon: 'none'
        });
      }
    } catch (error) {
      console.error('支付失败:', error);
      wx.showToast({
        title: '支付失败',
        icon: 'none'
      });
    }
  },

  // 确认收货
  async onConfirmOrder(e) {
    const { orderNo } = e.currentTarget.dataset
    
    try {
      const res = await api.confirmCustomerOrder(orderNo)
      if (res.success) {
        wx.showToast({
          title: '确认成功',
          icon: 'success'
        })
        
        // 延迟跳转到评价页面
        setTimeout(() => {
          console.log('确认收货成功，准备跳转至评价页面');
          wx.navigateTo({
            url: `/pages/review/review?orderNo=${orderNo}`,
            success: function(res) {
              console.log('跳转到评价页面成功', res);
            },
            fail: function(error) {
              console.error('跳转到评价页面失败', error);
              wx.showToast({
                title: '无法打开评价页面',
                icon: 'none'
              });
            }
          });
        }, 1500);
        
        // 重新加载订单列表
        this.setData({
          page: 1,
          orders: [],
          hasMore: true
        });
        this.loadOrders()
      } else {
        wx.showToast({
          title: res.message || '确认失败',
          icon: 'none'
        })
      }
    } catch (error) {
      console.error('确认收货失败:', error)
      wx.showToast({
        title: '确认失败',
        icon: 'none'
      })
    }
  },

  // 删除订单
  async deleteOrder(e) {
    const { orderNo } = e.currentTarget.dataset;
    
    wx.showModal({
      title: '提示',
      content: '确定要删除此订单吗？',
      success: async (res) => {
        if (res.confirm) {
          try {
            const res = await api.deleteCustomerOrder(orderNo);
            if (res.success) {
              wx.showToast({
                title: '删除成功',
                icon: 'success'
              });
              // 重新加载订单列表
              this.setData({
                page: 1,
                orders: [],
                hasMore: true
              });
              this.loadOrders();
            } else {
              wx.showToast({
                title: res.message || '删除失败',
                icon: 'none'
              });
            }
          } catch (error) {
            console.error('删除订单失败:', error);
            wx.showToast({
              title: '删除失败',
              icon: 'none'
            });
          }
        }
      }
    });
  },

  // 写评价
  writeReview(e) {
    const orderNo = e.currentTarget.dataset.orderNo;
    const order = this.data.orders.find(o => o.orderNo === orderNo);
    
    if (order && order.reviewed) {
      // 如果订单已评价，提示用户
      wx.showToast({
        title: '该订单已评价',
        icon: 'none'
      });
      return;
    }
    
    wx.navigateTo({
      url: `/pages/review/review?orderNo=${orderNo}`
    });
  },

  // 查看物流
  viewLogistics(e) {
    const { orderNo } = e.currentTarget.dataset;
    
    // 获取订单信息
    const orderIndex = this.data.orders.findIndex(order => order.orderNo === orderNo);
    if (orderIndex === -1) {
      wx.showToast({
        title: '订单不存在',
        icon: 'none'
      });
      return;
    }
    
    // 跳转到订单详情页面，带上物流标识
    wx.navigateTo({
      url: `/pages/order/detail/detail?orderNo=${orderNo}&tab=logistics`
    });
  },

  // 调试用方法，直接跳转到评价页面
  debugGoToReview() {
    console.log('调试: 直接跳转到评价页面');
    
    // 使用示例订单号
    const testOrderNo = '202502260117521461';
    
    // 直接跳转到评价页面
    wx.navigateTo({
      url: `/pages/review/review?orderNo=${testOrderNo}`,
      success: function(res) {
        console.log('调试: 跳转到评价页面成功', res);
      },
      fail: function(error) {
        console.error('调试: 跳转到评价页面失败', error);
        
        // 显示详细错误
        wx.showModal({
          title: '跳转失败',
          content: JSON.stringify(error),
          showCancel: false
        });
      }
    });
  },

  // 处理图片加载错误
  onImageError(e) {
    console.log('图片加载错误:', e);
    const { orderIndex, productIndex } = e.currentTarget.dataset;
    
    // 构建更新路径
    const updatePath = `orders[${orderIndex}].products[${productIndex}].imageUrl`;
    
    // 设置为默认图片
    this.setData({
      [updatePath]: '/images/default-product.png'
    });
  }
})
